import java.util.*;
/**
 * 链表区间反转
 * 反转从位置 left 到 right 的链表节点，返回反转后的链表头节点
 * 使用头插法实现，时间复杂度O(n)，空间复杂度O(1)
 */
public class reverseBetween {
    /**
     * 链表节点类
     * 包含节点值和指向下一个节点的引用
     */
    public static class ListNode{
        int val;        // 节点值
        ListNode next;  // 指向下一个节点的引用
        
        // 无参构造函数
        ListNode(){}
        
        // 带值的构造函数
        ListNode(int val){
            this.val = val;
        }
        
        // 带值和下一个节点的构造函数
        ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    /**
     * 反转链表指定区间的方法
     * 算法步骤：
     * 1. 找到区间起始位置的前一个节点pre
     * 2. 使用头插法反转区间内的节点
     * 3. 每次将当前节点的下一个节点插入到pre之后
     * 
     * 例如：1->2->3->4->5，left=2，right=4
     * 第一步：找到pre指向1
     * 第二步：将3插入到1后面：1->3->2->4->5
     * 第三步：将4插入到1后面：1->4->3->2->5
     * 
     * @param head 链表头节点
     * @param left 区间起始位置（从1开始）
     * @param right 区间结束位置
     * @return 反转后的链表头节点
     */
    public static ListNode reverseBetweenM(ListNode head, int left, int right){
        // 处理特殊情况：空链表、单节点链表、left等于right
        if(head == null || head.next == null || right == left) return head;
        
        // 创建虚拟头节点，简化操作
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;  // pre指向区间起始位置的前一个节点
        
        // 移动pre和head到区间起始位置
        // head初始值是指向1节点的，所以需要移动left-1次
        for(int i = 1; i < left; i++){  // i从1开始，因为链表位置从1开始计数；i < left表示需要移动left-1次
            pre = pre.next;
            head = head.next;
        }
        
        // 使用头插法反转区间内的节点
        ListNode tmp = null;
        for(int i = 1; i < right - left + 1; i++){  // i从1开始，表示反转操作的次数；right-left+1表示需要反转的节点个数
            tmp = head.next;           // 保存要移动的节点
            head.next = head.next.next;  // 从原位置删除该节点
            tmp.next = pre.next;       // 将节点插入到pre之后
            pre.next = tmp;            // 更新pre的next指针
        }
        
        return dummy.next;  // 返回反转后的链表头节点
    }

    /**
     * 主函数：处理输入输出
     * 输入格式：
     * 第一行：链表节点值，用空格分隔
     * 第二行：区间起始位置left
     * 第三行：区间结束位置right
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 读取链表节点值
        String[] s = sc.nextLine().split(" ");
        
        // 创建链表
        ListNode dummy = new ListNode(0);  // 虚拟头节点
        ListNode node = dummy;
        for(int i = 0; i < s.length; i++){
            node.next = new ListNode(Integer.parseInt(s[i]));
            node = node.next;
        }
        
        // 读取区间位置
        int left = sc.nextInt();
        sc.nextLine();  // 消耗换行符
        int right = sc.nextInt();
        sc.nextLine();  // 消耗换行符
        
        // 反转指定区间并输出结果
        ListNode result = reverseBetweenM(dummy.next, left, right);
        while(result != null){
            System.out.print(result.val + " ");
            result = result.next;
        }
        sc.close();
    }  
}
